home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / bbs / mxu_v152.zip / MAX_UPD.PAS < prev    next >
Pascal/Delphi Source File  |  1997-06-01  |  18KB  |  660 lines
  1. {
  2.  ▀▀▀▀▀▀▀▀  ▀▀▀▀▀▀    ▀▀   ▀▀
  3.    ▀▀     ▀▀   ▀▀   ▀▀  ▀▀
  4.   ▀▀     ▀▀   ▀▀▀  ▀▀▀▀▀  The DoorKit!
  5.  ▀▀     ▀▀   ▀▀   ▀▀  ▀▀
  6. ▀▀     ▀▀▀▀▀▀    ▀▀    ▀▀
  7. The BBS Door Development Kit By The People - For The People!
  8.  
  9.  
  10.    Feel free to modify or optimize this code at will. All I ask is that if
  11.    find a better way to do things (and you will), please send me a copy of
  12.    your modifications. Thanks in advance!....Larry L. Athey....
  13.  
  14. ───────────────────────────────────────────────────────────────────────────────
  15.  
  16. NOTE: This door requires Async Professional for DOS before you can
  17.       compile it.  The MAX_UPD.PAS unit can be easily modified for
  18.       use with any other protocol library or any external protocol
  19.       driver such as PDrive, DSZ, GSZ, CEXY, Etc.}
  20.  
  21. {$A+,B-,D+,E+,F+,G+,I-,L+,N-,O+,P-,Q-,R-,S-,T-,V+,X+}
  22. UNIT MAX_UPD;
  23.  
  24. INTERFACE
  25.  
  26. USES _EXIT,CRT,DOS,TDK_VARS,APVARS,__TEXT,_PROTO,
  27.      MAX_UNIT,DOORKIT1,DOORKIT2,DOORKIT3;
  28.  
  29. VAR
  30.   TheTerminal : STRING[80];
  31.   NewExe      : STRING[80];
  32.   NewOvr      : STRING[80];
  33.   Version     : STRING[4];
  34.   HomeDir     : STRING[67];
  35.   WorkPath    : STRING[80];
  36.   DropRIP     : BOOLEAN;
  37.   NewTerm     : BOOLEAN;
  38.   DropIt      : BOOLEAN;
  39.   Count       : LONGINT;
  40.   DT          : BYTE;
  41.  
  42. PROCEDURE ReadCfg;
  43. PROCEDURE MaxUpdate;
  44.  
  45. IMPLEMENTATION
  46.  
  47. PROCEDURE DoThePort;
  48. BEGIN
  49.   DoTextColors;
  50.   Colours.WindowHeaderForeE := 15;
  51.   Colours.WindowHeaderBack := 3;
  52.   IF Ctl.UseFossil THEN CommDef.Device := 2
  53.                    ELSE CommDef.Device := 1;
  54.   IF Ctl.UseDigi THEN CommDef.Device := 3;
  55.   IF Ctl.NSP THEN CommDef.Port := Ctl.Port
  56.              ELSE CommDef.Port := DoorSys.ComPort;
  57.   IF Ctl.NSP THEN CommDef.PortAddr := Ctl.HexAddr
  58.              ELSE CommDef.PortAddr := '0';
  59.   IF Ctl.NSP THEN CommDef.IRQ := Ctl.IRQ
  60.              ELSE CommDef.IRQ := 0;
  61.   ActualBaud := DoorSys.BaudRate;
  62. END;
  63.  
  64. PROCEDURE SendFiles(FTP : BYTE ; TheFile : STRING);
  65. VAR
  66.   Protocol : STRING[10];
  67. BEGIN
  68.   IF Graphics <> MAX THEN BEGIN
  69.     CASE FTP OF
  70.       1 : Protocol := 'Zmodem';
  71.       2 : Protocol := 'Xmodem';
  72.       3 : Protocol := 'Xmodem-1K';
  73.       4 : Protocol := 'Ymodem';
  74.       5 : Protocol := 'Ymodem-G';
  75.     END;
  76.     sClrScr;
  77.     IceText('Start Your ' + Protocol + ' Download Now!',TRUE);
  78.     IceText('Press CTRL-X Several Times To Abort.',TRUE);
  79.   END;
  80.   Wait(2);
  81.   ShowStatusBar;
  82.   AbortedProtocol := FALSE;
  83.   WeAbort         := FALSE;
  84.   IF Comm_Init THEN BEGIN
  85.     IF FTP IN [1,4,5] THEN TransmitFiles('',FTP)
  86.                       ELSE TransmitFiles(TheFile,FTP);
  87.   END;
  88.   DoorSys.IdleCount := 0;
  89.   UpdateTime;
  90.   ShowStatusBar;
  91.   PurgeInput;
  92.   PurgeOutput;
  93.   IF DataAvailable THEN WHILE DataAvailable DO GetChar;
  94. END;
  95.  
  96. PROCEDURE FixScreen(FName : STRING);
  97. VAR
  98.   Txt1 : TEXT;
  99.   Txt2 : TEXT;
  100.   St   : STRING;
  101.   Hide : WORD;
  102.   Show : WORD;
  103. BEGIN
  104.   Hide := 0;
  105.   Show := 0;
  106.   IF NOT FExist(FName + '.MAX') THEN EXIT;
  107.   ASSIGN(Txt1,FName + '.MAX');
  108.   ASSIGN(Txt2,FName + '.MA_');
  109.   RESET(Txt1);
  110.   REWRITE(Txt2);
  111.   WHILE NOT EOF(Txt1) DO BEGIN
  112.     READLN(Txt1,St);
  113.     St := StripBoth(St,' ');
  114.     IF (St = ' ~² ') OR (AllCaps(St) = 'START_SCREEN()') THEN St := ' ~ï ';
  115.     IF ((St = ' ~■ ') OR (AllCaps(St) = 'END_SCREEN()')) AND (Show = 0) THEN BEGIN
  116.       WRITELN(Txt2,' ~î ');
  117.       INC(Show);
  118.     END;
  119.     IF St = ' ~ï ' THEN INC(Hide);
  120.     IF St = ' ~î ' THEN INC(Show);
  121.     IF (St = ' ~ï ') AND (St <> #12) AND (Hide = 1) THEN WRITELN(Txt2,St);
  122.     IF (St = ' ~î ') AND (St <> #12) AND (Show = 1) THEN WRITELN(Txt2,St);
  123.     IF (St <> ' ~ï ') AND (St <> ' ~î ') AND (St <> #12) THEN WRITELN(Txt2,St);
  124.   END;
  125.   CLOSE(Txt1);
  126.   CLOSE(Txt2);
  127.   ERASE(Txt1);
  128.   CopyFile(FName + '.MA_',FName + '.MAX');
  129.   ERASE(Txt2);
  130. END;
  131.  
  132. PROCEDURE SystemScreen(FName : STRING);
  133. VAR
  134.   OldGraphics : BYTE;
  135. BEGIN
  136.   OldGraphics := Graphics;
  137.   IF Graphics = RIP THEN BEGIN
  138.     IF NOT FExist(FName + '.RIP') THEN BEGIN
  139.       RipToText;
  140.       Graphics := ANSI;
  141.     END;
  142.   END;
  143.   IF Graphics = MAX THEN BEGIN
  144.     IF NOT FExist(FName + '.MAX') THEN BEGIN
  145.       RipToText;
  146.       Graphics := ANSI;
  147.     END;
  148.   END;
  149.   IF (Graphics = AVATAR) AND (NOT FExist(FName + '.AVT')) THEN Graphics := ANSI;
  150.   IF (Graphics = ANSI) AND (NOT FExist(FName + '.ANS')) THEN Graphics := TTY;
  151.   IF Graphics <> MAX THEN sClrScr;
  152.   CASE Graphics OF
  153.     RIP    : ShowScreen(FName + '.RIP');
  154.     MAX    : ShowScreen(FName + '.MAX');
  155.     AVATAR : ShowScreen(FName + '.AVT');
  156.     ANSI   : ShowScreen(FName + '.ANS');
  157.     TTY    : BEGIN
  158.                Set_Color(7,0);
  159.                ShowScreen(FName + '.ASC');
  160.              END;
  161.   END;
  162.   Graphics := OldGraphics;
  163. END;
  164.  
  165. PROCEDURE CleanUpWorkDirectory; Far;
  166. VAR
  167.   WorkFile : STRING[12];
  168.   DirInfo  : SEARCHREC;
  169. BEGIN
  170.   CHDIR(NoPath(WorkPath));
  171.   FINDFIRST('*.*',Anyfile - Directory - VolumeID,DirInfo);
  172.   WHILE DOSERROR = 0 DO BEGIN
  173.     WorkFile := AllCaps(DirInfo.Name);
  174.     FErase(WorkFile);
  175.     FINDNEXT(DirInfo);
  176.   END;
  177.   CHDIR(HomeDir);
  178. END;
  179.  
  180. FUNCTION GetProtocol : BYTE;
  181. VAR
  182.   Ch   : CHAR;
  183.   Done : BOOLEAN;
  184. BEGIN
  185.   Done := FALSE;
  186.   SystemScreen('PROTOCOL');
  187.   IF Graphics <> MAX THEN sWrite(' ');
  188.   REPEAT
  189.     Ch := UPCASE(sReadKey);
  190.     OutTxt(15,0,Ch);
  191.     CASE Ch OF
  192.       '1' : BEGIN
  193.               GetProtocol := 1;
  194.               Done        := TRUE;
  195.               Log('ZModem Protocol Selected');
  196.             END;
  197.       '2' : BEGIN
  198.               GetProtocol := 4;
  199.               Done        := TRUE;
  200.               Log('YModem Protocol Selected');
  201.             END;
  202.       '3' : BEGIN
  203.               GetProtocol := 5;
  204.               Done        := TRUE;
  205.               Log('YModem-G Protocol Selected');
  206.             END;
  207.       '4' : BEGIN
  208.               GetProtocol := 2;
  209.               Done        := TRUE;
  210.               Log('XModem Protocol Selected');
  211.             END;
  212.       '5' : BEGIN
  213.               GetProtocol := 3;
  214.               Done        := TRUE;
  215.               Log('XModem-1K Protocol Selected');
  216.             END;
  217.       #13 : SystemScreen('PROTOCOL');
  218.       'Q' : BEGIN
  219.               GetProtocol := 0;
  220.               Done        := TRUE;
  221.             END;
  222.     END;
  223.   UNTIL Done;
  224. END;
  225.  
  226. PROCEDURE RipProcess;
  227. VAR
  228.   Ch : CHAR;
  229.   P  : BYTE;
  230. BEGIN
  231.   RipToText;
  232.   Graphics := ANSI;
  233.   Log('Informing RIPterm Caller Of MAXterm Policy');
  234.   SystemScreen('RIPTERM');
  235.   sWrite(' ');
  236.   REPEAT Ch := UPCASE(sReadKey) UNTIL Ch IN ['D','H','Q'];
  237.   OutTxt(15,0,Ch);
  238.   CASE Ch OF
  239.     'D' : BEGIN
  240.             P := GetProtocol;
  241.             IF P <> 0 THEN BEGIN
  242.               FileQueue[1] := TheTerminal;
  243.               FilesInQueue := 1;
  244.               IF P IN [2,3] THEN SendFiles(P,TheTerminal) ELSE SendFiles(P,'');
  245.             END;
  246.             IF DropRIP THEN _HangUp := TRUE;
  247.             HALT(ErrLevel);
  248.           END;
  249.     'H' : BEGIN
  250.             _HangUp := TRUE;
  251.             HALT(ErrLevel);
  252.           END;
  253.     'Q' : BEGIN
  254.             IF DropRIP THEN _HangUp := TRUE;
  255.             HALT(ErrLevel);
  256.           END;
  257.   END;
  258. END;
  259.  
  260. PROCEDURE AddToMaxQueue(TheFile : STRING);
  261. VAR
  262.   ULQ : TEXT;
  263. BEGIN
  264.   ASSIGN(ULQ,WorkPath + 'ULQUEUE.TXT');
  265.   IF NOT FExist(WorkPath + 'ULQUEUE.TXT') THEN BEGIN
  266.     REWRITE(ULQ);
  267.     CLOSE(ULQ);
  268.   END;
  269.   APPEND(ULQ);
  270.   WRITELN(ULQ,TheFile);
  271.   CLOSE(ULQ);
  272. END;
  273.  
  274. FUNCTION RemoteHasIt(TheFile,TheCrc : STRING) : BOOLEAN;
  275. VAR
  276.   TFile   : TEXT;
  277.   ResFile : STRING[12];
  278.   ResCrc  : STRING[8];
  279.   Temp    : STRING;
  280.   DoFile  : BOOLEAN;
  281.   DoCrc   : BOOLEAN;
  282.   Loop    : BYTE;
  283. BEGIN
  284.   RemoteHasIt := FALSE;
  285.   IF FExist(HomeDir + '\RES.' + IntToStr(DoorSys.Node)) THEN BEGIN
  286.     ASSIGN(TFile,HomeDir + '\RES.' + IntToStr(DoorSys.Node));
  287.     RESET(TFile);
  288.     WHILE NOT EOF(TFile) DO BEGIN
  289.       ResFile := '';
  290.       ResCrc  := '';
  291.       DoFile  := TRUE;
  292.       DoCrc   := FALSE;
  293.       READLN(TFile,Temp);
  294.       Temp := StripBoth(AllCaps(Temp),' ');
  295.       FOR Loop := 1 TO LENGTH(Temp) DO BEGIN
  296.         IF Temp[Loop] = ' ' THEN BEGIN
  297.           DoFile := FALSE;
  298.           DoCrc  := TRUE;
  299.         END;
  300.         IF (DoFile) AND (Temp[Loop] <> ' ') THEN ResFile := ResFile + Temp[Loop];
  301.         IF (DoCrc) AND (Temp[Loop] <> ' ') THEN ResCrc := ResCrc + Temp[Loop];
  302.       END;
  303.       IF ResCrc = '' THEN ResCrc := 'XXXXXXXX';
  304.       IF (ResFile = TheFile) AND (ResCrc = TheCrc) THEN BEGIN
  305.         RemoteHasIt := TRUE;
  306.         CLOSE(TFile);
  307.         EXIT;
  308.       END;
  309.     END;
  310.     CLOSE(TFile);
  311.     MaxCommand(' }╬' + #39 + TheFile + #39 + ' ');
  312.   END;
  313. END;
  314.  
  315. FUNCTION CheckResources(StuffIt : BOOLEAN) : BOOLEAN;
  316. VAR
  317.   DirList : TEXT;
  318.   ResList : TEXT;
  319.   ResFile : STRING[12];
  320.   ResCrc  : STRING[8];
  321.   TheDir  : STRING;
  322.   Temp    : STRING;
  323.   DoFile  : BOOLEAN;
  324.   DoCrc   : BOOLEAN;
  325.   Loop    : BYTE;
  326. BEGIN
  327.   Count          := 0;
  328.   CheckResources := FALSE;
  329.   ASSIGN(DirList,'DIR.LST');
  330.   RESET(DirList);
  331.   WHILE NOT EOF(DirList) DO BEGIN
  332.     READLN(DirList,TheDir);
  333.     TheDir := NoPath(TheDir);
  334.     CHDIR(TheDir);
  335.     IF FExist('RESOURCE.LST') THEN BEGIN
  336.       ASSIGN(ResList,'RESOURCE.LST');
  337.       RESET(ResList);
  338.       WHILE NOT EOF(ResList) DO BEGIN
  339.         ResFile := '';
  340.         ResCrc  := '';
  341.         DoFile  := TRUE;
  342.         DoCrc   := FALSE;
  343.         READLN(ResList,Temp);
  344.         Temp := StripBoth(AllCaps(Temp),' ');
  345.         FOR Loop := 1 TO LENGTH(Temp) DO BEGIN
  346.           IF Temp[Loop] = ' ' THEN BEGIN
  347.             DoFile := FALSE;
  348.             DoCrc  := TRUE;
  349.           END;
  350.           IF (DoFile) AND (Temp[Loop] <> ' ') THEN ResFile := ResFile + Temp[Loop];
  351.           IF (DoCrc) AND (Temp[Loop] <> ' ') THEN ResCrc := ResCrc + Temp[Loop];
  352.         END;
  353.         IF (NOT RemoteHasIt(ResFile,ResCrc)) AND (FExist(ResFile)) THEN BEGIN
  354.           INC(Count);
  355.           CheckResources := TRUE;
  356.           IF StuffIt THEN BEGIN
  357.             CopyFile(ResFile,WorkPath + ResFile);
  358.             AddToMaxQueue(WorkPath + ResFile);
  359.             IF ResFile = 'BACKDROP.MAX' THEN DropIt := TRUE;
  360.           END;
  361.         END;
  362.       END;
  363.       CLOSE(ResList);
  364.     END;
  365.     CHDIR(HomeDir);
  366.   END;
  367.   CLOSE(DirList);
  368. END;
  369.  
  370. FUNCTION CheckOneList(StuffIt : BOOLEAN) : BOOLEAN;
  371. VAR
  372.   ResList : TEXT;
  373.   ResFile : STRING[12];
  374.   ResCrc  : STRING[8];
  375.   TheDir  : STRING;
  376.   Temp    : STRING;
  377.   DoFile  : BOOLEAN;
  378.   DoCrc   : BOOLEAN;
  379.   Loop    : BYTE;
  380. BEGIN
  381.   Count        := 0;
  382.   CheckOneList := FALSE;
  383.   IF FExist(MiscFile) THEN BEGIN
  384.     CHDIR(NoPath(GetFilePath(MiscFile)));
  385.     ASSIGN(ResList,MiscFile);
  386.     RESET(ResList);
  387.     WHILE NOT EOF(ResList) DO BEGIN
  388.       ResFile := '';
  389.       ResCrc  := '';
  390.       DoFile  := TRUE;
  391.       DoCrc   := FALSE;
  392.       READLN(ResList,Temp);
  393.       Temp := StripBoth(AllCaps(Temp),' ');
  394.       FOR Loop := 1 TO LENGTH(Temp) DO BEGIN
  395.         IF Temp[Loop] = ' ' THEN BEGIN
  396.           DoFile := FALSE;
  397.           DoCrc  := TRUE;
  398.         END;
  399.         IF (DoFile) AND (Temp[Loop] <> ' ') THEN ResFile := ResFile + Temp[Loop];
  400.         IF (DoCrc) AND (Temp[Loop] <> ' ') THEN ResCrc := ResCrc + Temp[Loop];
  401.       END;
  402.       IF (NOT RemoteHasIt(ResFile,ResCrc)) AND (FExist(ResFile)) THEN BEGIN
  403.         INC(Count);
  404.         CheckOneList := TRUE;
  405.         IF StuffIt THEN BEGIN
  406.           CopyFile(ResFile,WorkPath + ResFile);
  407.           AddToMaxQueue(WorkPath + ResFile);
  408.           IF ResFile = 'BACKDROP.MAX' THEN DropIt := TRUE;
  409.         END;
  410.       END;
  411.     END;
  412.     CLOSE(ResList);
  413.   END;
  414.   CHDIR(HomeDir);
  415. END;
  416.  
  417. PROCEDURE QueryTerminal;
  418. VAR
  419.   TFile   : TEXT;
  420.   ResFile : STRING[12];
  421. BEGIN
  422.   SendStr(#13#10);
  423.   SendStr(#12#13#10);
  424.   MaxCommand(' ~ì19 ');
  425.   NoKill := TRUE;
  426.   FixScreen('QUERY1');
  427.   SystemScreen('QUERY1');
  428.   Log('Getting Remote System Information');
  429.   Wait(3);
  430.   MaxCommand(' }═ ');
  431.   Wait(3);
  432.   NoKill := TRUE;
  433.   FixScreen('QUERY2');
  434.   SystemScreen('QUERY2');
  435.   Log('Getting Remote System Resource List');
  436.   Wait(3);
  437.   MaxCommand(' }╔ ');
  438.   Wait(3);
  439.   IF FExist('KILL.LST') THEN BEGIN
  440.     ASSIGN(TFile,'KILL.LST');
  441.     RESET(TFile);
  442.     WHILE NOT EOF(TFile) DO BEGIN
  443.       READLN(TFile,ResFile);
  444.       ResFile := StripBoth(AllCaps(ResFile),' ');
  445.       MaxCommand(' }╬' + #39 + ResFile + #39 + ' ');
  446.     END;
  447.     CLOSE(TFile);
  448.   END;
  449.   MaxCommand(' ~ì0 ');
  450.   SendStr(#13#10);
  451.   SendStr(#12#13#10);
  452. END;
  453.  
  454. PROCEDURE CheckTerminal;
  455. VAR
  456.   Info : TEXT;
  457.   St   : STRING;
  458. BEGIN
  459.   Count    := 0;
  460.   NewTerm  := TRUE;
  461.   ShowLog  := TRUE;
  462.   TextAttr := 7;
  463.   CLRSCR;
  464.   IF FExist('REMOTE.' + IntToStr(DoorSys.Node)) THEN BEGIN
  465.     ASSIGN(Info,'REMOTE.' + IntToStr(DoorSys.Node));
  466.     RESET(Info);
  467.     WHILE NOT EOF(Info) DO BEGIN
  468.       INC(Count);
  469.       READLN(Info,St);
  470.       IF (Count = 2) AND (POS(Version,St) > 0) THEN NewTerm := FALSE;
  471.       Log(St);
  472.     END;
  473.     CLOSE(Info);
  474.   END;
  475.   IF NewTerm THEN BEGIN
  476.     Log('Outdated MAXterm Program Detected');
  477.     SystemScreen('BADTERM');
  478.     sReadKey;
  479.     SendStr(#13#10);
  480.     SendStr(#12#13#10);
  481.     Log('Updating Remote Caller''s MAXterm Program');
  482.     FileQueue[1] := NewExe;
  483.     FileQueue[2] := NewOvr;
  484.     FilesInQueue := 2;
  485.     ShowLog      := FALSE;
  486.     SendFiles(1,'');
  487.   END;
  488. END;
  489.  
  490. PROCEDURE DoMaxFiles;
  491. VAR
  492.   Info : TEXT;
  493.   St   : STRING;
  494.   Ch   : CHAR;
  495. BEGIN
  496.   ShowLog := TRUE;
  497.   SystemScreen('UPDATEYN');
  498.   REPEAT Ch := UPCASE(sReadKey) UNTIL Ch IN ['Y','N'];
  499.   IF Ch = 'N' THEN BEGIN
  500.     IF NewTerm THEN BEGIN
  501.       _HangUp := TRUE;
  502.       ShowLog := FALSE;
  503.       RipToText;
  504.       HALT(ErrLevel);
  505.     END;
  506.     Log('Caller Aborted Full Resource Update Process');
  507.     ShowLog := FALSE;
  508.     HALT(ErrLevel);
  509.   END ELSE Log('Running Full Resource Update Process');
  510.   MaxCommand(' ~ì19 ');
  511.   SystemScreen('UDNOTICE');
  512.   Log('Comparing Remote and Local Resource Lists');
  513.   IF MiscFile = '' THEN CheckResources(TRUE);
  514.   IF MiscFile <> '' THEN CheckOneList(TRUE);
  515.   Log('Sending ' + IntToStr(Count) + ' Resource Files Via Zmodem');
  516.   ASSIGN(Info,WorkPath + 'ULQUEUE.TXT');
  517.   RESET(Info);
  518.   MaxCommand(' }╩ ');
  519.   Wait(2);
  520.   MaxCommand(' }╩ ');
  521.   FilesInQueue := 0;
  522.   ShowLog      := FALSE;
  523.   WHILE NOT EOF(Info) DO BEGIN
  524.     INC(FilesInQueue);
  525.     READLN(Info,FileQueue[FilesInQueue]);
  526.     IF FilesInQueue = 15 THEN BEGIN
  527.       SendFiles(1,'');
  528.       FILLCHAR(FileQueue,SIZEOF(FileQueue),0);
  529.       FilesInQueue := 0;
  530.     END;
  531.   END;
  532.   CLOSE(Info);
  533.   IF FilesInQueue > 0 THEN SendFiles(1,'');
  534.   MaxCommand(' }╠ ');
  535.   Wait(2);
  536.   MaxCommand(' }╠ ');
  537.   MaxCommand(' ~ì0 ');
  538.   MaxCommand(' }╨ ');
  539.   IF Count > 0 THEN BEGIN
  540.     IF (WeAbort) OR (AbortedProtocol) THEN BEGIN
  541.       SystemScreen('UPD_FAIL');
  542.       sReadKey;
  543.     END ELSE BEGIN
  544.       IF (DropIt) OR (NewTerm) THEN SystemScreen('UPD_DROP') ELSE SystemScreen('UPD_DONE');
  545.       sReadKey;
  546.     END;
  547.   END;
  548.   ShowLog := FALSE;
  549.   CleanUpWorkDirectory;
  550.   IF (DropIt) OR (NewTerm) THEN BEGIN
  551.     IF NewTerm THEN BEGIN
  552.       SystemScreen('TERMNOTE');
  553.       sReadKey;
  554.     END;
  555.     _HangUp := TRUE;
  556.     RipToText;
  557.   END;
  558.   Wait(5);
  559.   WINDOW(1,1,80,25);
  560.   HALT(ErrLevel);
  561. END;
  562.  
  563. PROCEDURE AnsiTtyProcess;
  564. VAR
  565.   Ch : CHAR;
  566.   P  : BYTE;
  567. BEGIN
  568.   CASE Graphics OF
  569.     AVATAR : Insert1 := 'AVATAR';
  570.     ANSI   : Insert1 := 'ANSI';
  571.     TTY    : Insert1 := 'ASCII';
  572.     RIP    : Insert1 := 'RIP';
  573.   END;
  574.   Log('Offering MAXterm To ' + Insert1 + ' Caller');
  575.   SystemScreen('MAXTERM');
  576.   sWrite(' ');
  577.   REPEAT Ch := UPCASE(sReadKey) UNTIL Ch IN ['Y','N'];
  578.   OutTxt(15,0,Ch);
  579.   IF (NOT Local) AND (Ch = 'Y') THEN BEGIN
  580.     P := GetProtocol;
  581.     IF P <> 0 THEN BEGIN
  582.       Log('Caller Downloading MAXterm');
  583.       FileQueue[1] := TheTerminal;
  584.       FilesInQueue := 1;
  585.      IF P IN [2,3] THEN SendFiles(P,TheTerminal) ELSE SendFiles(P,'');
  586.     END;
  587.   END;
  588.   IF Ch = 'N' THEN Log(Insert1 + ' Caller Declined MAXterm Offer');
  589.   HALT(ErrLevel);
  590. END;
  591.  
  592. PROCEDURE ReadCfg;
  593. VAR
  594.   Cfg   : TEXT;
  595.   DTstr : STRING[3];
  596. BEGIN
  597.   IF NOT FExist('UP_DOOR.CFG') THEN ErrorLog('CRITICAL ERROR: UP_DOOR.CFG IS MISSING!',6,TRUE);
  598.   DropRIP := FALSE;
  599.   ASSIGN(Cfg,'UP_DOOR.CFG');
  600.   RESET(Cfg);
  601.   READLN(Cfg,DTstr); DT := StrToInt(DTstr);
  602.   READLN(Cfg,Version);
  603.   READLN(Cfg,TheTerminal);
  604.   READLN(Cfg,NewExe);
  605.   READLN(Cfg,NewOvr);
  606.   READLN(Cfg,LogPath);
  607.   READLN(Cfg,LogFile);
  608.   READLN(Cfg,DTstr);
  609.   IF POS('Y',AllCaps(DTstr)) > 0 THEN DropRIP := TRUE;
  610.   CLOSE(Cfg);
  611.   LogPath := CvtVars(LogPath);
  612.   LogFile := CvtVars(LogFile);
  613. END;
  614.  
  615. PROCEDURE MaxUpdate;
  616. BEGIN
  617.   DropIt  := FALSE;
  618.   NewTerm := FALSE;
  619.   GETDIR(0,HomeDir);
  620.   WorkPath := HomeDir + '\WORK' + IntToStr(DoorSys.Node) + '\';
  621.   MakeDir(WorkPath);
  622.   AddToExitChain(CleanUpWorkDirectory);
  623.   ReadCfg;
  624.   MaxID := Version;
  625.   CleanUpWorkDirectory;
  626.   DoThePort;
  627.   IF Graphics = RIP THEN RipProcess ELSE
  628.   IF Graphics = MAX THEN BEGIN
  629.     IF NOT FExist('DIR.LST') THEN ErrorLog('CRITICAL ERROR: DIR.LST IS MISSING!',6,TRUE);
  630.     ShowProgramAd;
  631.     WINDOW(1,6,80,24);
  632.     QueryTerminal;
  633.     CheckTerminal;
  634.     IF MiscFile = '' THEN BEGIN
  635.       IF CheckResources(FALSE) THEN BEGIN
  636.         Log('Update Method: Complete DIR.LST/RESOURCE.LST');
  637.         Log('Remote Needs ' + IntToStr(Count) + ' Resource Files');
  638.         DoMaxFiles;
  639.       END;
  640.     END ELSE BEGIN
  641.       IF CheckOneList(FALSE) THEN BEGIN
  642.         Log('Update Method: Singular RESOURCE.LST');
  643.         Log('Remote Needs ' + IntToStr(Count) + ' Resource Files');
  644.         DoMaxFiles;
  645.       END;
  646.     END;
  647.     IF NewTerm THEN BEGIN
  648.       SystemScreen('TERMNOTE');
  649.       sReadKey;
  650.       _HangUp := TRUE;
  651.       RipToText;
  652.       Wait(5);
  653.       WINDOW(1,1,80,25);
  654.       HALT(ErrLevel);
  655.     END;
  656.   END ELSE AnsiTtyProcess;
  657. END;
  658.  
  659. END.
  660.